'''
Created on 13/10/2013

@author: daniel
'''
import colecciones.cola
import colecciones.listaEnlazada
import ej1DefinicionDeGrafo.grafo
import ej1DefinicionDeGrafo.vertice
import unittest


class Recorridos(object):
    '''
    La clase recorridos tiene los metodos  dfs y bfs para asociarlos en un grafo, por lo
    tanto el grafo se asocia al recorrido
    '''
    def dfs(self, grafo, origen): 
        '''
        Imprime los vertices del grafo a partir del recorrido en profundidad desde 
        el vertice origen.
        '''
        visitado = [False]*grafo.getListaDeVertices().getTamanio()#la otra inicializacion del vector no funciona
        self.__dfs__(origen, visitado)

    def __dfs__(self, origen, visitado):
        '''
        recorrido en profundidad proporcionado por la catedra
        origen es el vertice de partida
        visitado es el vector de etiquetas del grafo para cada vertice
        '''
        print origen.getDato()
        visitado[origen.getPosicion()]=True
        recorredor = origen.getListaDeAdyacentes().recorredor()
        recorredor.comenzar()
        while not recorredor.fin():
            ady = recorredor.elemento().getVerticeDestino()
            if not visitado[ady.getPosicion()]:self.__dfs__(ady, visitado)
            recorredor.proximo()
    
    def bfs(self, grafo, origen):
        '''
        Imprime los vertices del grafo a partir del recorrido en amplitud desde el vertice origen
        grafo es el entorno que contiene vertices
        origen es el vertice de partida
        '''
        visitado = [False]*grafo.getListaDeVertices().getTamanio()#la otra inicializacion del vector no funciona
        self.__bfs__(origen, visitado)
    
    def __bfs__(self, origen, visitado):
        '''
        recorrido en amplitud proporcionado por la catedra:
        origen es el vertice de partida
        visitado es el vector de etiquetas del grafo para cada vertice
        '''
        cola=colecciones.cola.Cola()
        cola.poner(origen)
        while not cola.esVacia():
            vertice = cola.sacar()
            if not visitado[vertice.getPosicion()]:
                print vertice.getDato()
                visitado[vertice.getPosicion()]=True#visita al actual
                recorredor = vertice.getListaDeAdyacentes().recorredor()
                recorredor.comenzar()
                while not recorredor.fin():#si tiene adyacentes los pone en cola 
                    ady = recorredor.elemento().getVerticeDestino()
                    if not visitado[ady.getPosicion()]:cola.poner(ady)
                    recorredor.proximo()

    def __bfsListado__(self, origen, visitado):
        '''
        recorrido en amplitud devuelto en una lista:
        origen es el vertice de partida
        visitado es el vector de etiquetas del grafo para cada vertice
        '''
        lista=colecciones.listaEnlazada.ListaEnlazada()
        cola=colecciones.cola.Cola()
        cola.poner(origen)
        while not cola.esVacia():
            vertice = cola.sacar()
            if not visitado[vertice.getPosicion()]:
                lista.agregar(vertice,lista.getTamanio())
                visitado[vertice.getPosicion()]=True#visita al actual
                recorredor = vertice.getListaDeAdyacentes().recorredor()
                recorredor.comenzar()
                while not recorredor.fin():#si tiene adyacentes los pone en cola 
                    ady = recorredor.elemento().getVerticeDestino()
                    if not visitado[ady.getPosicion()]:cola.poner(ady)
                    recorredor.proximo()
        return lista
    
    def caminoSimpleConDFS(self, grafo, origen, destino):
        '''
        Retorna una lista de vertices con el recorrido en profundidad del grafo
        recibido como parametro desde el vertice origen hasta el vertice destino
        '''
        lista=colecciones.listaEnlazada.ListaEnlazada()
        visitado = [False]*grafo.getListaDeVertices().getTamanio()#la otra inicializacion del vector no funciona
        self.__recCaminoSimpleDFS__(origen, lista, visitado,destino)
        return lista
            
    def __recCaminoSimpleDFS__(self,origen,lista,visitado,destino):
        if origen.__cmp__(destino)==0:return True #si encontro destino
        visitado[origen.getPosicion()]=True#sino recorre
        recorredor = origen.getListaDeAdyacentes().recorredor()
        recorredor.comenzar()
        while not recorredor.fin():
            ady = recorredor.elemento().getVerticeDestino()
            if not visitado[ady.getPosicion()]:
                if(self.__recCaminoSimpleDFS__(ady,lista,visitado,destino)==True):#si en el recorrido encuentra camino
                    lista.agregar(ady,lista.getTamanio())#guarda en la lista
                    return True#corta recorrido y devuelve para avisar que es parte del camino
            recorredor.proximo()
        return False
    
    def verticesADistanciaConBFS(self, grafo, origen, nroDeAristas):
        '''
        Retorna la lista de vertices que se encuentran a la distancia (en numeros 
        de aristas) que se indica en el parametro nroDeAristas con el recorrido en 
        amplitud del grafo recibido como parametro partiendo del vertice origen
        '''
        visitado = [False]*grafo.getListaDeVertices().getTamanio()#la otra inicializacion del vector no funciona
        if (nroDeAristas<=0):return colecciones.listaEnlazada.ListaEnlazada()
        lista=self.__bfsListadoADistancia__(origen, visitado)
#         print "Lista producida"
#         print lista
        rec=lista.recorredor()
        rec.comenzar()
        lista1=colecciones.listaEnlazada.ListaEnlazada()
        while not rec.fin():
            elem=rec.elemento()
            if (elem[1]==nroDeAristas)&(not lista1.incluye(elem[0])): 
                lista1.agregar(elem[0],0)
            rec.proximo()
        return lista1
    
    def __bfsListadoADistancia__(self,origen, visitado):
        '''
        recorrido en amplitud devuelto en una lista:
        origen es el vertice de partida
        visitado es el vector de etiquetas del grafo para cada vertice
        '''
        lista=colecciones.listaEnlazada.ListaEnlazada()
        cola=colecciones.cola.Cola()
        cola.poner([origen,0])#el cero es la distancia
        while not cola.esVacia():
            vertice = cola.sacar()
            if not visitado[vertice[0].getPosicion()]:
                visitado[vertice[0].getPosicion()]=True#visita al actual
                recorredor = vertice[0].getListaDeAdyacentes().recorredor()
                recorredor.comenzar()
                while not recorredor.fin():#si tiene adyacentes los pone en cola 
                    ady = recorredor.elemento().getVerticeDestino()
                    if not visitado[ady.getPosicion()]:
                        cola.poner([ady,vertice[1]+1])
                        lista.agregar([ady,vertice[1]+1],0)
                    recorredor.proximo()
        return lista       
        
    def __esAdyacente__(self,origen,destino):
        if origen is None or destino is None : return False
        rec=origen.getListaDeAdyacentes().recorredor()
        rec.comenzar()
        while not rec.fin():
            ady=rec.elemento()
            if(ady.getVerticeDestino() is destino):return True
            rec.proximo()
        return False

    
class Test(unittest.TestCase):


    def testName(self):
        self.assertIsInstance(Recorridos(), Recorridos,"Verifica la correcta creacion de los recoridos")
    
    def testDfs(self):
        grafo=ej1DefinicionDeGrafo.grafo.Grafo()
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(1,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                            )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(2,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(3,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(4,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(5,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(6,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(7,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.conectar(grafo.vertice(0), grafo.vertice(3), 0)# 1 con 4
        grafo.conectar(grafo.vertice(0), grafo.vertice(1), 0)# 1 con 2
        grafo.conectar(grafo.vertice(1), grafo.vertice(4), 0)# 2 con 5
        grafo.conectar(grafo.vertice(2), grafo.vertice(4), 0)# 3 con 5
        grafo.conectar(grafo.vertice(3), grafo.vertice(5), 0)# 4 con 6
        grafo.conectar(grafo.vertice(3), grafo.vertice(1), 0)# 4 con 2
        grafo.conectar(grafo.vertice(3), grafo.vertice(2), 0)# 4 con 3
        grafo.conectar(grafo.vertice(3), grafo.vertice(4), 0)# 4 con 5
        grafo.conectar(grafo.vertice(4), grafo.vertice(6), 0)# 5 con 7
        grafo.conectar(grafo.vertice(5), grafo.vertice(6), 0)# 6 con 7
        grafo.conectar(grafo.vertice(5), grafo.vertice(2), 0)# 6 con 3
        print "Recorrido En profundidad:"
        dfs=Recorridos()
        dfs.dfs(grafo, grafo.vertice(0))
         

    def testBfs(self):
        grafo=ej1DefinicionDeGrafo.grafo.Grafo()
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(1,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                            )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(2,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(3,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(4,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(5,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(6,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(7,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.conectar(grafo.vertice(0), grafo.vertice(3), 0)# 1 con 4
        grafo.conectar(grafo.vertice(0), grafo.vertice(1), 0)# 1 con 2
        grafo.conectar(grafo.vertice(1), grafo.vertice(4), 0)# 2 con 5
        grafo.conectar(grafo.vertice(2), grafo.vertice(4), 0)# 3 con 5
        grafo.conectar(grafo.vertice(3), grafo.vertice(5), 0)# 4 con 6
        grafo.conectar(grafo.vertice(3), grafo.vertice(1), 0)# 4 con 2
        grafo.conectar(grafo.vertice(3), grafo.vertice(2), 0)# 4 con 3
        grafo.conectar(grafo.vertice(3), grafo.vertice(4), 0)# 4 con 5
        grafo.conectar(grafo.vertice(4), grafo.vertice(6), 0)# 5 con 7
        grafo.conectar(grafo.vertice(5), grafo.vertice(6), 0)# 6 con 7
        grafo.conectar(grafo.vertice(5), grafo.vertice(2), 0)# 6 con 3
        print "Recorrido en amplitud:"
        bfs=Recorridos()
        bfs.bfs(grafo, grafo.vertice(0))
        
    def testCaminoSimpleConDFS(self):
        grafo=ej1DefinicionDeGrafo.grafo.Grafo()
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(1,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                            )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(2,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(3,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(4,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(5,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(6,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(7,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.conectar(grafo.vertice(0), grafo.vertice(3), 0)# 1 con 4
        grafo.conectar(grafo.vertice(0), grafo.vertice(1), 0)# 1 con 2
        grafo.conectar(grafo.vertice(1), grafo.vertice(4), 0)# 2 con 5
        grafo.conectar(grafo.vertice(2), grafo.vertice(4), 0)# 3 con 5
        grafo.conectar(grafo.vertice(3), grafo.vertice(5), 0)# 4 con 6
        grafo.conectar(grafo.vertice(3), grafo.vertice(1), 0)# 4 con 2
        grafo.conectar(grafo.vertice(3), grafo.vertice(2), 0)# 4 con 3
        grafo.conectar(grafo.vertice(3), grafo.vertice(4), 0)# 4 con 5
        grafo.conectar(grafo.vertice(4), grafo.vertice(6), 0)# 5 con 7
        grafo.conectar(grafo.vertice(5), grafo.vertice(6), 0)# 6 con 7
        grafo.conectar(grafo.vertice(5), grafo.vertice(2), 0)# 6 con 3
        camino=Recorridos()
        lista=camino.caminoSimpleConDFS(grafo,grafo.vertice(0),grafo.vertice(4))
        '''
        se verifica camino mas profundo desde el vertice que contiene el 1
        hasta el vertice que contiene al 5
        '''
        self.assertEquals(lista.elemento(3), grafo.vertice(3), "verifica comino siguiente al vertice 0,es el que contiene al 4")
        self.assertEquals(lista.elemento(2), grafo.vertice(5), "verifica comino siguiente al vertice 3,es el que contiene al 6")
        self.assertEquals(lista.elemento(1), grafo.vertice(2), "verifica comino siguiente al vertice 5,es el que contiene al 3")
        self.assertEquals(lista.elemento(0), grafo.vertice(4), "verifica comino siguiente al vertice 2,es el que contiene al 5")
        

    def testVerticesADistanciaConBFS(self):
        grafo=ej1DefinicionDeGrafo.grafo.Grafo()
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(1,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                            )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(2,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(3,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(4,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(5,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(6,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.agregarVertice(
                 ej1DefinicionDeGrafo.vertice.Vertice(7,
                          colecciones.listaEnlazada.ListaEnlazada()
                                    )
                          )
        grafo.conectar(grafo.vertice(0), grafo.vertice(3), 0)# 1 con 4
        grafo.conectar(grafo.vertice(0), grafo.vertice(1), 0)# 1 con 2
        grafo.conectar(grafo.vertice(1), grafo.vertice(4), 0)# 2 con 5
        grafo.conectar(grafo.vertice(2), grafo.vertice(4), 0)# 3 con 5
        grafo.conectar(grafo.vertice(3), grafo.vertice(5), 0)# 4 con 6
        grafo.conectar(grafo.vertice(3), grafo.vertice(1), 0)# 4 con 2
        grafo.conectar(grafo.vertice(3), grafo.vertice(2), 0)# 4 con 3
        grafo.conectar(grafo.vertice(3), grafo.vertice(4), 0)# 4 con 5
        grafo.conectar(grafo.vertice(4), grafo.vertice(6), 0)# 5 con 7
        grafo.conectar(grafo.vertice(5), grafo.vertice(6), 0)# 6 con 7
        grafo.conectar(grafo.vertice(5), grafo.vertice(2), 0)# 6 con 3
        camino=Recorridos()
        self.assertTrue(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),0).esVacia(),"Verifica que no hay vertices a distancia 0")
        self.assertIsNotNone(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),1),"Verifica que hay vertices a distancia 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),1).elemento(0),grafo.vertice(3),"verifica que el primer elemento de la lista de vertices desde el 1 sea el vertice 4 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),1).elemento(1),grafo.vertice(1),"verifica que el segundo elemento de la lista de vertices desde el 1 sea el vertice 2 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),2).elemento(0),grafo.vertice(5),"verifica que el primer elemento de la lista de vertices desde el 1 sea el vertice 6 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),2).elemento(1),grafo.vertice(1),"verifica que el segundo elemento de la lista de vertices desde el 1 sea el vertice 2 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),2).elemento(2),grafo.vertice(2),"verifica que el tercer elemento de la lista de vertices desde el 1 sea el vertice 3 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),2).elemento(3),grafo.vertice(4),"verifica que el cuarto elemento de la lista de vertices desde el 1 sea el vertice 5 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),3).elemento(0),grafo.vertice(2),"verifica que el primer elemento de la lista de vertices desde el 1 sea el vertice 3 con dist 3")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),3).elemento(1),grafo.vertice(4),"verifica que el segundo elemento de la lista de vertices desde el 1 sea el vertice 5 con dist 3")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),3).elemento(2),grafo.vertice(6),"verifica que el tercer elemento de la lista de vertices desde el 1 sea el vertice 7 con dist 3")
        self.assertTrue(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),4).esVacia(),"verifica que  la lista de vertices desde el 1 sea vacia a dist 4")
        self.assertTrue(camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),0).esVacia(),"Verifica que no hay vertices a distancia 0")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),1).elemento(0),grafo.vertice(4),"verifica que el primer elemento de la lista de vertices desde el 2 sea el vertice 5 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),2).elemento(0),grafo.vertice(6),"verifica que el segundo elemento de la lista de vertices desde el 2 sea el vertice 7 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),1).elemento(0),grafo.vertice(4),"verifica que el primer elemento de la lista de vertices desde el 3 sea el vertice 5 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),2).elemento(0),grafo.vertice(6),"verifica que el segundo elemento de la lista de vertices desde el 3 sea el vertice 7 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),1).elemento(0),grafo.vertice(5),"verifica que el primer elemento de la lista de vertices desde el 4 sea el vertice 6 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),1).elemento(1),grafo.vertice(1),"verifica que el segundo elemento de la lista de vertices desde el 4 sea el vertice 2 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),1).elemento(2),grafo.vertice(2),"verifica que el tercer elemento de la lista de vertices desde el 4 sea el vertice 3 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),1).elemento(3),grafo.vertice(4),"verifica que el cuarto elemento de la lista de vertices desde el 4 sea el vertice 5 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),2).elemento(0),grafo.vertice(2),"verifica que el primer elemento de la lista de vertices desde el 4 sea el vertice 3 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),2).elemento(1),grafo.vertice(4),"verifica que el segundo elemento de la lista de vertices desde el 4 sea el vertice 5 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),2).elemento(2),grafo.vertice(6),"verifica que el tercer elemento de la lista de vertices desde el 4 sea el vertice 7 con dist 2")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(4),1).elemento(0),grafo.vertice(6),"verifica que el primer elemento de la lista de vertices desde el 5 sea el vertice 7 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),1).elemento(0),grafo.vertice(6),"verifica que el primer elemento de la lista de vertices desde el 6 sea el vertice 7 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),1).elemento(1),grafo.vertice(2),"verifica que el segundo elemento de la lista de vertices desde el 6 sea el vertice 3 con dist 1")
        self.assertEquals(camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),2).elemento(0),grafo.vertice(4),"verifica que el primer elemento de la lista de vertices desde el 6 sea el vertice 5 con dist 5")
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),1)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),2)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),3)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),4)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),5)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),6)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(0),7)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),1)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),2)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),3)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),4)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),5)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),6)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(1),7)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),1)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),2)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),3)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),4)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),5)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),6)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(2),7)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),1)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),2)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),3)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),4)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),5)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),6)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(3),7)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(4),1)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(4),2)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(4),3)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(4),4)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(4),5)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(4),6)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(4),7)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),1)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),2)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),3)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),4)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),5)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),6)
#         print camino.verticesADistanciaConBFS(grafo,grafo.vertice(5),7)
        
if __name__ == "__main__":
    #import sys;sys.argv = ['', 'Test.testName']
    unittest.main()